/*
 *
 * Copyright (c) 2021
 * User:Dybala
 * File:TaskService.java
 * Date:2021/11/18 17:23:18
 */

package com.service;

import com.dao.TaskDao;
import com.dao.UserDao;
import com.pojo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class TaskService {
    @Autowired
    private TaskDao taskdao;

    @Autowired
    private UserDao userdao;
    @Autowired
    private MailService mailService;

    public List<TaskMini> getAllTasks(){
        List<TaskMini> tasks = taskdao.queryAllTask();
        return tasks;
    }

    /**
     * 通过id获取任务详细信息
     * @param id 任务id
     * @return
     */
    public Task getTaskById(int id){
        Task task = taskdao.queryById(id);
        return task;
    }

    /**
     * 添加任务
     * @param task 待添加的任务
     * @return message，代表添加成功或失败
     */
    public Message addTask(Task task){
        Message res=new Message();
        // 首先校验这个用户的状态
        String email = task.getPublisher();
        User user = userdao.queryByEmail(email);
        if(user==null){
            res.setFlag(410);
            res.setMsg("您的账号未知错误");
            return res;
        }
        // 判断状态
        if(judgeStatus(user)==false){
            res.setFlag(410);
            res.setMsg("您的账号暂时未处于active，请联系管理员");
            return res;
        }
        int count = taskdao.countMyTasks(email);
        if(count>10){
            res.setFlag(410);
            res.setMsg("您发布的任务已超过上限，请撤回一些任务以便发布新任务");
            return res;
        }
        //添加任务
        task.setPublisherName(user.getUsername());
        taskdao.addTask(task);
        //插入id到pretasks
        int id = task.getId();
        taskdao.insertToPreTasks(id);
        res.setFlag(200);
        res.setMsg("添加成功");
        return res;
    }

    /**
     * 校验用户状态
     * @param user 待校验用户的
     * @return 是否处于激活状态
     */
    private boolean judgeStatus(User user){
        String status = user.getStatus();
        return "active".equals(status);
    }

    /**
     * 通过email查看当前还有多少条任务
     * @param email
     * @return
     */
    public int getCount(String email){
        int count = taskdao.countMyTasks(email);
        return count;
    }

    /**
     * 获取email对应用户的所有待接收任务
     * @param email
     * @return
     */
    public List<Task> getAllMyTasks(String email){
        List<Task> tasks = taskdao.queryByEmail(email);
        return tasks;
    }

    /**
     * 撤销一个任务
     * @param email
     * @param id
     * @return
     */
    public Message withDraw(String email,int id){
        Message msg=new Message();
//        Task task = taskdao.queryByEmailAndId(email, id);
        // 没有查到这个任务
        Integer num = taskdao.queryPreTask(id);
        Task task = taskdao.queryByEmailAndId(email, id);
        if(num==null||task==null){
            msg.setFlag(400);
            msg.setMsg("没有查询到相关任务，请重试");
            return msg;
        }else{
            // 如果拿到了这个任务, 执行删除
            taskdao.deleteById(id);
            taskdao.deletePreTask(id);
            msg.setFlag(200);
            msg.setMsg("删除成功");
        }
        return msg;
    }

    public List<Task> getTaskByOrder(int tag_id){
        return taskdao.queryByOrder(tag_id);
    }

    /**
     * 接受任务
     * @param id 接受任务的编号
     * @param email 接收者的邮箱
     * @return
     */
    public Message acceptTask(int id,String email){
        Message msg=new Message();
        // 1. 首先校验用户账号是否异常
        User user = userdao.queryByEmail(email);
        if(user==null){
            msg.setFlag(400);
            msg.setMsg("账号异常");
            return msg;
        }
        String status = user.getStatus();
        if(!"active".equals(status)){
            msg.setFlag(400);
            msg.setMsg("账号状态异常，请联系管理员");
        }else{
            //2. 查看任务是否存在
            Integer num = taskdao.queryPreTask(id);
            if(num==null){
                msg.setFlag(400);
                msg.setMsg("手慢了，该任务已被接手");
                return msg;
            }
            //限定最多同时接受7个
            int count = taskdao.queryPubByEmail(email).size();
            if(count>7){
                msg.setFlag(400);
                msg.setMsg("任务已经超过七个，无法继续接受");
                return msg;
            }
            Task task = taskdao.queryById(id);
            String publisher = task.getPublisher();
            if(email.equals(publisher)){
                msg.setFlag(400);
                msg.setMsg("不能自己接自己的任务");
                return msg;
            }
            //3. 先从pretasks表中删除，然后加入wokringtasks表。
            task = taskdao.queryById(id);
            taskdao.deletePreTask(id);
            taskdao.insertToWorking(id,email,task.getPublisher());
            //4. 获取发布者的联系方式
            msg.setFlag(200);
            User user2 = userdao.queryByEmail(task.getPublisher());
            msg.setMsg("接单成功，发布者联系方式为： "+ user2.getPhone());

        }
        return msg;
    }

    public void notifyTask(String customeremail,int id){

        Task task = taskdao.queryAllById(id);
        User publisher = userdao.queryByEmail(task.getPublisher());
        User customer = userdao.queryByEmail(customeremail);

        StringBuilder sb=new StringBuilder();
        sb.append("任务已被接受： \n").append("任务id： ").append(task.getId()).append("\n").append("任务标题:").append(task.getTitle()).append("\n").append("接收者联系方式: ").append(customer.getPhone());
        mailService.sendSimpleMail(task.getPublisher(),"任务接受信息",sb.toString());
        sb=new StringBuilder();
        sb.append("已接受任务：\n").append("任务id： ").append(task.getId()).append("\n").append("任务标题:").append(task.getTitle()).append("\n").append("发布者联系方式: ").append(publisher.getPhone());
        mailService.sendSimpleMail(customer.getEmail(),"接收成功消息",sb.toString());
    }

    public List<PubTask> queryPub(String email){
        List<PubTask> tasks = taskdao.queryPubByEmail(email);
        return tasks;
    }

    public PubTask queryPubDeatils(String email,int id){

        PubTask PubTask = taskdao.queryPubByEmailAndId(email, id);
        return PubTask;
    }

    /**
     * 确认完成任务
     * @param email
     * @param id
     * @return
     */
    public PubTask finishTask(String email,int id){

        //1. 在workingtask中获取，然后从workingtask中删除
        PubTask task = queryPubDeatils(email, id);
        if(task==null){
            return null;
        }else{
            taskdao.deleteWorking(email,id);
            //2. 加入finished_task表
            taskdao.insertToFinished(email,id);
        }
        //3. 返回信息
        return task;
    }

    public List<PubTask>queryFinished(String email){
        List<PubTask> pubTasks = taskdao.queryFinishedList(email);
        return pubTasks;
    }
    public Message writeComment(Comment comment,String email){
        Message msg=new Message();
        //校验参数
        int score = comment.getScore();
        if(score<0||score>100){
            msg.setFlag(400);
            msg.setMsg("评分范围出错");
            return msg;
        }
        // 校验评价的任务的发布者是不是自己,并且任务已经完成
        String publisher = taskdao.queryFinishedPublisherEmailById(comment.getId());

//        System.out.println(publisher+" "+email);
        if(!email.equals(publisher)){
            msg.setFlag(400);
            msg.setMsg("只能对自己发布的任务进行评价");
            return msg;
        }else{
            //查看是否已经进行过评价
            if(taskdao.searchComment(comment.getId())!=null){
                msg.setFlag(400);
                msg.setMsg("请不要重复评价");
                return msg;
            }

            //没有进行过评价
            taskdao.writeFeedBack(comment);
            //写入finish
            taskdao.updateFinishedTaskScore(comment.getId(),comment.getScore());
            msg.setFlag(200);
            msg.setMsg("评价成功");
        }
        return msg;
    }

    /**
     * 接收者查看自己完成的某项具体任务
     * @param email
     * @param id
     * @return
     */
    public HistoryTask checkSpecial(String email,int id){
        HistoryTask res=new HistoryTask();
        // 1.校验id对应的任务的接收者是不是email
//        String str = taskdao.queryFinishedEmailById(id);
        String customer = taskdao.queryFinishedCustomerEmailById(id);
//        System.out.println(customer);
        if(!email.equals(customer)){
            // 自己不是接收者看不了
            return null;
        }else{
            Comment comment = taskdao.searchComment(id);
            res.setComment(comment);
            PubTask pubTask = taskdao.queryFinishedPubTaskById(email,id);
            res.setTask(pubTask);
        }
        return res;
    }

    /**
     * 处理投诉事务,自己是发布者，投诉接收者没办好事情
     * @param report 投诉的具体内容
     * @return
     */
    public Message reporter(Report report){
        Message msg=new Message();
        //1. 首先校验身份，查看发布者是不是自己
        String str = taskdao.queryFinishedPublisherEmailById(report.getTask_id());
        if(!report.getLanucher().equals(str)){
            msg.setFlag(400);
            msg.setMsg("只能对自己发布的已完成的任务进行反馈");
        }else{
            //确实是自己发布的任务
            String customer = taskdao.queryFinishedCustomerEmailById(report.getTask_id());
            report.setUndertaker(customer);
            //看自己之前有没有投诉过
            int num = taskdao.queryReportByEmailAndId(report.getLanucher(), report.getTask_id(),0);
            if(num!=0){
                //有相关记录了，只能更新
                taskdao.updateReportByEmailAndTaskIdAndType(report);
                msg.setFlag(200);
                msg.setMsg("已更新您的投诉");

            }else{
                int res = taskdao.reportToAdmin(report);
                if(res==0){
                    msg.setFlag(400);
                    msg.setMsg("请重试");
                }else{
                    msg.setFlag(200);
                    msg.setMsg("已更新您的投诉");
                }
            }
        }
        return msg;
    }

//    public List<Task>
    public List<Map<String ,Object >> getFinishedTask(String email){
        List<Map<String, Object>> maps = taskdao.queryFinishedTaskByEmail(email);
        return maps;
    }

    /**
     * 举报任务不符合规范，比如语言攻击
     * @param report
     * @return
     */
    public Message reportPreTask(Report report){
        Message msg=new Message();
        int num = taskdao.queryReportByEmailAndId(report.getLanucher(), report.getTask_id(),1);
        if(num!=0){
            msg.setFlag(400);
            msg.setMsg("已经举报过了");
            return msg;
        }
        Task task = taskdao.queryAllById(report.getTask_id());
        report.setUndertaker(task.getPublisher());
        int res = taskdao.reportToAdmin(report);
        if(res==0){
            msg.setFlag(400);
            msg.setMsg("请重试");
        }else{
            msg.setFlag(200);
            msg.setMsg("收到您的投诉");
        }
        return msg;
    }

    /**
     * 在帖子详情页发表评论
     * @param discussion
     * @return
     */
    public Message addDiscussion(Discussion discussion) {
        Message msg = new Message();
        String senderEmail = discussion.getSenderEmail();
        User sender = userdao.queryByEmail(senderEmail);
        //检查账号是否存在
        if(sender == null) {
            msg.setFlag(410);
            msg.setMsg("您的账号未知错误");
            return msg;
        }
        //检查账号状态，是否可以发评论
        if(!judgeStatus(sender)) {
            msg.setFlag(410);
            msg.setMsg("您的账号暂不能发表评论，请联系管理员");
            return msg;
        }
        if(discussion.getReceiverEmail()==null){
            int taskId = discussion.getTaskId();
            Task task = taskdao.queryAllById(taskId);
//            System.out.println(task);
            String publisher = task.getPublisher();
            discussion.setReceiverEmail(publisher);
        }

        //添加评论
        taskdao.addDiscussion(discussion);
        msg.setFlag(200);
        msg.setMsg("评论成功");
        return msg;
    }

    /**
     * 在帖子详情页查看与用户相关的评论
     * @param taskId 帖子ID
     * @param email 用户身份标识（邮箱）
     * @return 与用户有关的评论列表
     */
    public List<Discussion> getMyDiscussions(int taskId, String email) {
        //校验用户状态
        if(email == null) {
            return null;
        }
        List<Discussion> discussions = taskdao.queryMyDiscussions(taskId, email);
        return discussions;
    }

    /**
     * 在帖子详情页查看所有评论
     * @param taskId 帖子ID
     * @param email 用户身份标识（邮箱）
     * @return 所有评论列表
     */
    public List<Discussion> getAllDiscussions(int taskId, String email) {
        //校验用户状态
        if(email == null) {
            return null;
        }
        List<Discussion> discussions = taskdao.queryAllDiscussions(taskId);
        return discussions;
    }

    /**
     * 查询谁正在给我执行任务，谁正再给我打工
     * @param email
     * @return
     */
    public List<PubTask> queryWorkers(String email) {
        List<PubTask> pubTasks = taskdao.queryMyWorker(email);
        return pubTasks;
    }

}
